const express = require('express');
const path = require('path');
const fs = require('fs');
const DatabaseLayer = require('./database');

const app = express();
const PORT = process.env.PORT || 3000;
const HOST = process.env.HOST || 'localhost';
const VIDEO_DIR = process.env.VIDEO_DIR || path.join(__dirname, 'videos');

// 初始化数据库
const db = new DatabaseLayer();

// 中间件配置
app.use(express.json());
app.use(express.static('public'));

// 确保视频目录存在
if (!fs.existsSync(VIDEO_DIR)) {
    fs.mkdirSync(VIDEO_DIR, { recursive: true });
    console.log(`创建视频目录: ${VIDEO_DIR}`);
}

// API路由

// 获取视频列表
app.get('/api/videos', (req, res) => {
    const { search, tag, series, limit, offset } = req.query;

    const params = {};
    if (search) params.search = search;
    if (tag) params.tag = tag;
    if (series) params.series = series;
    if (limit) params.limit = parseInt(limit);
    if (offset) params.offset = parseInt(offset);

    db.getVideos(params, (err, videos) => {
        if (err) {
            res.status(500).json({ error: '获取视频列表失败' });
        } else {
            res.json(videos);
        }
    });
});

// 搜索视频
app.get('/api/videos/search', (req, res) => {
    const { q } = req.query;

    if (!q) {
        return res.status(400).json({ error: '搜索关键词不能为空' });
    }

    db.getVideos({ search: q }, (err, videos) => {
        if (err) {
            res.status(500).json({ error: '搜索失败' });
        } else {
            res.json(videos);
        }
    });
});

// 获取单个视频详情
app.get('/api/videos/:id', (req, res) => {
    const { id } = req.params;

    db.getVideoById(id, (err, video) => {
        if (err) {
            res.status(500).json({ error: '获取视频详情失败' });
        } else if (!video) {
            res.status(404).json({ error: '视频不存在' });
        } else {
            res.json(video);
        }
    });
});

// 更新视频元数据
app.put('/api/videos/:id', (req, res) => {
    const { id } = req.params;
    const updates = req.body;

    // 验证必需字段
    if (!updates.title) {
        return res.status(400).json({ error: '标题不能为空' });
    }

    db.updateVideo(id, updates, (result) => {
        if (!result.success) {
            res.status(500).json({ error: result.error });
        } else if (result.changes === 0) {
            res.status(404).json({ error: '视频不存在' });
        } else {
            res.json({ success: true, message: '更新成功' });
        }
    });
});

// 扫描导入视频
app.post('/api/scan-videos', (req, res) => {
    const { videoDir, directory } = req.body;
    const scanDir = videoDir || directory || VIDEO_DIR;

    if (!fs.existsSync(scanDir)) {
        return res.status(400).json({ error: '目录不存在' });
    }

    db.scanVideos(scanDir, (result) => {
        if (!result.success) {
            res.status(500).json({ error: result.error });
        } else {
            res.json({
                success: true,
                message: `扫描完成，导入 ${result.imported} 个视频，跳过 ${result.skipped} 个重复视频`,
                ...result
            });
        }
    });
});

// 获取所有标签
app.get('/api/tags', (req, res) => {
    db.getAllTags((err, tags) => {
        if (err) {
            res.status(500).json({ error: '获取标签失败' });
        } else {
            res.json(tags);
        }
    });
});

// 获取所有系列
app.get('/api/series', (req, res) => {
    db.getAllSeries((err, series) => {
        if (err) {
            res.status(500).json({ error: '获取系列失败' });
        } else {
            res.json(series.map(s => s.series).filter(s => s));
        }
    });
});

// 视频流播放接口
app.get('/api/video/:filename', (req, res) => {
    const { filename } = req.params;

    // 安全验证：防止路径遍历攻击
    if (filename.includes('..') || filename.includes('/') || filename.includes('\\')) {
        return res.status(400).json({ error: '无效的文件名' });
    }

    // 从数据库获取视频的实际文件路径
    db.getVideos({}, (err, videos) => {
        if (err) {
            return res.status(500).json({ error: '获取视频信息失败' });
        }

        const video = videos.find(v => v.filename === filename);
        if (!video) {
            return res.status(404).json({ error: '视频不存在' });
        }

        const videoPath = video.filepath;

        // 检查文件是否存在
        if (!fs.existsSync(videoPath)) {
            return res.status(404).json({ error: '视频文件不存在' });
        }

        const stat = fs.statSync(videoPath);
        const fileSize = stat.size;
        const range = req.headers.range;

        // 支持HTTP Range请求
        if (range) {
            const parts = range.replace(/bytes=/, "").split("-");
            const start = parseInt(parts[0], 10);
            const end = parts[1] ? parseInt(parts[1], 10) : fileSize - 1;
            const chunksize = (end - start) + 1;
            const file = fs.createReadStream(videoPath, { start, end });

            const head = {
                'Content-Range': `bytes ${start}-${end}/${fileSize}`,
                'Accept-Ranges': 'bytes',
                'Content-Length': chunksize,
                'Content-Type': 'video/mp4',
            };

            res.writeHead(206, head);
            file.pipe(res);
        } else {
            const head = {
                'Content-Length': fileSize,
                'Content-Type': 'video/mp4',
            };

            res.writeHead(200, head);
            fs.createReadStream(videoPath).pipe(res);
        }

        // 记录播放次数（异步）
        db.incrementViewCount(video.id, () => { });
    });
});

// 获取视频文件信息
app.get('/api/video-info/:filename', (req, res) => {
    const { filename } = req.params;

    // 安全验证
    if (filename.includes('..') || filename.includes('/') || filename.includes('\\')) {
        return res.status(400).json({ error: '无效的文件名' });
    }

    const videoPath = path.join(VIDEO_DIR, filename);

    if (!fs.existsSync(videoPath)) {
        return res.status(404).json({ error: '视频文件不存在' });
    }

    const stat = fs.statSync(videoPath);
    res.json({
        filename,
        filesize: stat.size,
        created: stat.birthtime,
        modified: stat.mtime
    });
});

// 健康检查接口
app.get('/api/health', (req, res) => {
    res.json({
        status: 'ok',
        timestamp: new Date().toISOString(),
        videoDir: VIDEO_DIR
    });
});

// 默认路由 - 提供前端页面
app.get('/', (req, res) => {
    res.sendFile(path.join(__dirname, 'public', 'index.html'));
});

// 错误处理中间件
app.use((err, req, res, next) => {
    console.error('服务器错误:', err);
    res.status(500).json({ error: '服务器内部错误' });
});

// 404处理
app.use((req, res) => {
    res.status(404).json({ error: '接口不存在' });
});

// 启动服务器
app.listen(PORT, HOST, () => {
    console.log(`个人智能视频库系统启动成功！`);
    console.log(`服务地址: http://${HOST}:${PORT}`);
    console.log(`视频目录: ${VIDEO_DIR}`);
    console.log(`数据库文件: ${path.join(__dirname, 'videos.db')}`);
});

// 优雅关闭
process.on('SIGINT', () => {
    console.log('\n正在关闭服务器...');
    db.close();
    process.exit(0);
});

process.on('SIGTERM', () => {
    console.log('\n正在关闭服务器...');
    db.close();
    process.exit(0);
});

module.exports = app;
